package service

import (
	"apiGateWay/internal/config"
	"apiGateWay/internal/database"
	"apiGateWay/internal/model"
	"apiGateWay/internal/repository"
	"apiGateWay/pkg/logger"
	"encoding/json"
	"fmt"
)

// ConfigService 配置服务
type ConfigService struct {
	configRepo repository.ConfigRepository
}

// NewConfigService 创建配置服务
func NewConfigService() *ConfigService {
	return &ConfigService{
		configRepo: repository.NewConfigRepository(database.DB),
	}
}

// GetJWTConfig 从数据库获取 JWT 配置
func (s *ConfigService) GetJWTConfig() (*config.JWTConfig, error) {
	if database.DB == nil {
		return nil, fmt.Errorf("数据库未初始化")
	}

	systemConfig, err := s.configRepo.GetByKey("jwt")
	if err != nil {
		logger.Warnf("从数据库获取 JWT 配置失败，使用默认配置: %v", err)
		return nil, err
	}

	if systemConfig.Value == nil {
		return nil, fmt.Errorf("JWT 配置为空")
	}

	// 从 JSON 值中提取配置
	valueBytes, err := json.Marshal(systemConfig.Value)
	if err != nil {
		return nil, fmt.Errorf("序列化 JWT 配置失败: %w", err)
	}

	var jwtConfig config.JWTConfig
	if err := json.Unmarshal(valueBytes, &jwtConfig); err != nil {
		return nil, fmt.Errorf("反序列化 JWT 配置失败: %w", err)
	}

	return &jwtConfig, nil
}

// SaveJWTConfig 保存 JWT 配置到数据库
func (s *ConfigService) SaveJWTConfig(jwtConfig *config.JWTConfig) error {
	valueBytes, err := json.Marshal(jwtConfig)
	if err != nil {
		return fmt.Errorf("序列化 JWT 配置失败: %w", err)
	}

	var valueMap map[string]interface{}
	if err := json.Unmarshal(valueBytes, &valueMap); err != nil {
		return fmt.Errorf("反序列化 JWT 配置失败: %w", err)
	}

	systemConfig := &model.SystemConfig{
		Key:      "jwt",
		Category: "auth",
		Value:    valueMap,
	}

	return s.configRepo.Save(systemConfig)
}

// GetRateLimitConfig 从数据库获取限流配置
func (s *ConfigService) GetRateLimitConfig() (*config.RateLimitConfig, error) {
	if database.DB == nil {
		return nil, fmt.Errorf("数据库未初始化")
	}

	systemConfig, err := s.configRepo.GetByKey("rate_limit")
	if err != nil {
		logger.Warnf("从数据库获取限流配置失败，使用默认配置: %v", err)
		return nil, err
	}

	if systemConfig.Value == nil {
		return nil, fmt.Errorf("限流配置为空")
	}

	valueBytes, err := json.Marshal(systemConfig.Value)
	if err != nil {
		return nil, fmt.Errorf("序列化限流配置失败: %w", err)
	}

	var rateLimitConfig config.RateLimitConfig
	if err := json.Unmarshal(valueBytes, &rateLimitConfig); err != nil {
		return nil, fmt.Errorf("反序列化限流配置失败: %w", err)
	}

	return &rateLimitConfig, nil
}

// SaveRateLimitConfig 保存限流配置到数据库
func (s *ConfigService) SaveRateLimitConfig(rateLimitConfig *config.RateLimitConfig) error {
	valueBytes, err := json.Marshal(rateLimitConfig)
	if err != nil {
		return fmt.Errorf("序列化限流配置失败: %w", err)
	}

	var valueMap map[string]interface{}
	if err := json.Unmarshal(valueBytes, &valueMap); err != nil {
		return fmt.Errorf("反序列化限流配置失败: %w", err)
	}

	systemConfig := &model.SystemConfig{
		Key:      "rate_limit",
		Category: "rate_limit",
		Value:    valueMap,
	}

	return s.configRepo.Save(systemConfig)
}

// GetCORSConfig 从数据库获取 CORS 配置
func (s *ConfigService) GetCORSConfig() (*config.CORSConfig, error) {
	if database.DB == nil {
		return nil, fmt.Errorf("数据库未初始化")
	}

	systemConfig, err := s.configRepo.GetByKey("cors")
	if err != nil {
		logger.Warnf("从数据库获取 CORS 配置失败，使用默认配置: %v", err)
		return nil, err
	}

	if systemConfig.Value == nil {
		return nil, fmt.Errorf("CORS 配置为空")
	}

	valueBytes, err := json.Marshal(systemConfig.Value)
	if err != nil {
		return nil, fmt.Errorf("序列化 CORS 配置失败: %w", err)
	}

	var corsConfig config.CORSConfig
	if err := json.Unmarshal(valueBytes, &corsConfig); err != nil {
		return nil, fmt.Errorf("反序列化 CORS 配置失败: %w", err)
	}

	return &corsConfig, nil
}

// SaveCORSConfig 保存 CORS 配置到数据库
func (s *ConfigService) SaveCORSConfig(corsConfig *config.CORSConfig) error {
	valueBytes, err := json.Marshal(corsConfig)
	if err != nil {
		return fmt.Errorf("序列化 CORS 配置失败: %w", err)
	}

	var valueMap map[string]interface{}
	if err := json.Unmarshal(valueBytes, &valueMap); err != nil {
		return fmt.Errorf("反序列化 CORS 配置失败: %w", err)
	}

	systemConfig := &model.SystemConfig{
		Key:      "cors",
		Category: "cors",
		Value:    valueMap,
	}

	return s.configRepo.Save(systemConfig)
}

// GetSecurityConfig 从数据库获取安全配置
func (s *ConfigService) GetSecurityConfig() (*config.SecurityConfig, error) {
	if database.DB == nil {
		return nil, fmt.Errorf("数据库未初始化")
	}

	systemConfig, err := s.configRepo.GetByKey("security")
	if err != nil {
		logger.Warnf("从数据库获取安全配置失败，使用默认配置: %v", err)
		return nil, err
	}

	if systemConfig.Value == nil {
		return nil, fmt.Errorf("安全配置为空")
	}

	valueBytes, err := json.Marshal(systemConfig.Value)
	if err != nil {
		return nil, fmt.Errorf("序列化安全配置失败: %w", err)
	}

	var securityConfig config.SecurityConfig
	if err := json.Unmarshal(valueBytes, &securityConfig); err != nil {
		return nil, fmt.Errorf("反序列化安全配置失败: %w", err)
	}

	return &securityConfig, nil
}

// SaveSecurityConfig 保存安全配置到数据库
func (s *ConfigService) SaveSecurityConfig(securityConfig *config.SecurityConfig) error {
	valueBytes, err := json.Marshal(securityConfig)
	if err != nil {
		return fmt.Errorf("序列化安全配置失败: %w", err)
	}

	var valueMap map[string]interface{}
	if err := json.Unmarshal(valueBytes, &valueMap); err != nil {
		return fmt.Errorf("反序列化安全配置失败: %w", err)
	}

	systemConfig := &model.SystemConfig{
		Key:      "security",
		Category: "security",
		Value:    valueMap,
	}

	return s.configRepo.Save(systemConfig)
}

// GetOrLoadConfig 获取配置，如果数据库中没有则从传入的默认配置加载
func (s *ConfigService) GetOrLoadConfig(key string, category string, defaultValue interface{}) (map[string]interface{}, error) {
	if database.DB == nil {
		return nil, fmt.Errorf("数据库未初始化")
	}

	systemConfig, err := s.configRepo.GetByKey(key)
	if err != nil || systemConfig.Value == nil {
		// 数据库中没有配置，使用默认值并保存
		logger.Infof("数据库中未找到 %s 配置，使用默认配置并保存", key)
		valueBytes, err := json.Marshal(defaultValue)
		if err != nil {
			return nil, fmt.Errorf("序列化默认配置失败: %w", err)
		}

		var valueMap map[string]interface{}
		if err := json.Unmarshal(valueBytes, &valueMap); err != nil {
			// 如果不是 map，尝试直接转换
			if m, ok := defaultValue.(map[string]interface{}); ok {
				valueMap = m
			} else {
				return nil, fmt.Errorf("默认配置类型错误")
			}
		}

		systemConfig = &model.SystemConfig{
			Key:      key,
			Category: category,
			Value:    valueMap,
		}
		if err := s.configRepo.Save(systemConfig); err != nil {
			logger.Errorf("保存默认配置失败: %v", err)
		}

		return valueMap, nil
	}

	return systemConfig.Value, nil
}

// Save 保存配置（兼容 ConfigRepository 接口）
func (s *ConfigService) Save(config *model.SystemConfig) error {
	if database.DB == nil {
		return fmt.Errorf("数据库未初始化")
	}
	return s.configRepo.CreateOrUpdate(config)
}

// GetConfigByKey 根据 key 获取配置
func (s *ConfigService) GetConfigByKey(key string) (*model.SystemConfig, error) {
	if database.DB == nil {
		return nil, fmt.Errorf("数据库未初始化")
	}
	return s.configRepo.GetByKey(key)
}

